package cn.tedu.number;

import java.util.*;

/**
 * 由于业绩优秀，公司给小Q放了 n 天的假，身为工作狂的小Q打算在在假期中工作、锻炼或者休息。他有个奇怪的习惯：不会连续两天工作或锻炼。
 * 只有当公司营业时，小Q才能去工作，只有当健身房营业时，小Q才能去健身，小Q一天只能干一件事。给出假期中公司，健身房的营业情况，求小Q最少需要休息几天。
 * <p>
 * 输入描述:
 * 第一行一个整数 n(1 <= n <= 100000) 表示放假天数
 * 第二行 n 个数 每个数为0或1,第 i 个数表示公司在第 i 天是否营业
 * 第三行 n 个数 每个数为0或1,第 i 个数表示健身房在第 i 天是否营业
 * （1为营业 0为不营业）
 * <p>
 * 输出描述:
 * 一个整数，表示小Q休息的最少天数
 * <p>
 * 输入例子1:
 * 4
 * 1 1 0 0
 * 0 1 1 0
 * <p>
 * 输出例子1:
 * 2
 * <p>
 * 例子说明1:
 * 小Q可以在第一天工作，第二天或第三天健身，小Q最少休息2天
 */
public class HolidayEveryOtherDay {
    private enum PLAN {
        REST,
        WORK,
        FITNESS,
        MAX
    }

    public static void main(String[] args) {
        int a = PLAN.FITNESS.ordinal();

        Scanner input = new Scanner(System.in);
        int holidayCount = input.nextInt();

        PLAN[] plan = new PLAN[holidayCount];
        Arrays.fill(plan, PLAN.REST);

        int[] companyDay = new int[holidayCount];
        int[] gymDay = new int[holidayCount];
        for (int i = 0; i < holidayCount; i++) {
            companyDay[i] = input.nextInt();
        }
        for (int i = 0; i < holidayCount; i++) {
            gymDay[i] = input.nextInt();
        }

        if (holidayCount == 1) {
            if (companyDay[0] == 1 || gymDay[0] == 1)
                System.out.println("0");
            else
                System.out.println("1");
            return;
        }

        System.out.println(calcHoliday(companyDay, gymDay, plan, 0, holidayCount, holidayCount));
        // System.out.println(dpCalcHoliday(companyDay, gymDay, holidayCount));
    }

    private static boolean isWorking(int value) {
        return value == 1;
    }

    /**
     * 递归计算剩余假期
     * @param companyDay
     * @param gymDay
     * @param plan
     * @param now
     * @param total
     * @param remaining
     * @return
     */
    private static int calcHoliday(int[] companyDay, int[] gymDay, PLAN[] plan, int now, int total, int remaining) {
        if (now >= total)
            return remaining;
        // 今天公司和健身房都不营业，那么今天休息，直接判断明天
        if (!isWorking(companyDay[now]) && !isWorking(gymDay[now]))
            return calcHoliday(companyDay, gymDay, plan, now + 1, total, remaining);

        int last = now - 1;
        if (last >= 0) {
            PLAN lastPlan = plan[last];

            // 继续休息，可以无视昨天的状态
            PLAN[] tmpPlan = Arrays.copyOf(plan, total);
            tmpPlan[now] = PLAN.REST;
            int rest = calcHoliday(companyDay, gymDay, tmpPlan, now + 1, total, remaining);

            if (lastPlan == PLAN.WORK) {
                // 昨天工作了，那么今天一定不工作
                if (isWorking(gymDay[now])) {
                    tmpPlan = Arrays.copyOf(plan, total);
                    tmpPlan[now] = PLAN.FITNESS;
                    int fitness = calcHoliday(companyDay, gymDay, tmpPlan, now + 1, total, remaining - 1);
                    return Math.min(rest, fitness);
                }
                return rest;
            } else if (lastPlan == PLAN.FITNESS) {
                if (isWorking(companyDay[now])) {
                    tmpPlan = Arrays.copyOf(plan, total);
                    tmpPlan[now] = PLAN.WORK;
                    int work = calcHoliday(companyDay, gymDay, tmpPlan, now + 1, total, remaining - 1);
                    return Math.min(rest, work);
                }
                return rest;
            } else {
                int work = remaining;
                if (isWorking(companyDay[now])) {
                    tmpPlan = Arrays.copyOf(plan, total);
                    tmpPlan[now] = PLAN.WORK;
                    work = calcHoliday(companyDay, gymDay, tmpPlan, now + 1, total, remaining - 1);
                }
                int fitness = remaining;
                if (isWorking(gymDay[now])) {
                    tmpPlan = Arrays.copyOf(plan, total);
                    tmpPlan[now] = PLAN.FITNESS;
                    fitness = calcHoliday(companyDay, gymDay, tmpPlan, now + 1, total, remaining - 1);
                }
                return Math.min(Math.min(fitness, work), rest);
            }
        } else {
            // 今天是第一天
            // 先计算今天休息的情况
            PLAN[] tmpPlan = Arrays.copyOf(plan, total);
            tmpPlan[now] = PLAN.REST;
            int rest = calcHoliday(companyDay, gymDay, tmpPlan, now + 1, total, remaining);
            int work = remaining;
            if (isWorking(companyDay[now])) {
                // 今天公司营业，计算今天工作的情况
                tmpPlan = Arrays.copyOf(plan, total);
                tmpPlan[now] = PLAN.WORK;
                work = calcHoliday(companyDay, gymDay, tmpPlan, now + 1, total, remaining - 1);
            }
            int fitness = remaining;
            if (isWorking(gymDay[now])) {
                // 今天健身房营业，计算健身的情况
                tmpPlan = Arrays.copyOf(plan, total);
                tmpPlan[now] = PLAN.FITNESS;
                fitness = calcHoliday(companyDay, gymDay, tmpPlan, now + 1, total, remaining - 1);
            }
            return Math.min(Math.min(rest, work), fitness);
        }
    }

    /**
     * 数组缓存计算剩余假期
     * @param companyDay
     * @param gymDay
     * @param total
     */
    private static int dpCalcHoliday(int[] companyDay, int[] gymDay, int total) {
        // 初始化矩阵的数值
        int[][] dp = new int[PLAN.MAX.ordinal()][total];
        // 第一天如果休息，休息天数为1
        dp[PLAN.REST.ordinal()][0] = 1;

        if (isWorking(companyDay[0])) // 如果可以工作，休息天数为0
            dp[PLAN.WORK.ordinal()][0] = 0;

        if (isWorking(dp[PLAN.FITNESS.ordinal()][0])) // 如果可以健身，休息天数为0
            dp[PLAN.FITNESS.ordinal()][0] = 0;

        // 一共放了n天假，每天有三个选择，也就是组成3 * n的矩阵。
        for (int i = 1; i < total; i++) {
            if (isWorking(companyDay[i])) { // 如果公司开门，可以上班
                if (isWorking(gymDay[i - 1])) { // 如果昨天可以去健身
                    // dp[PLAN.WORK.ordinal()][i] = min(前一天休息，前一天健身);
                    // 因为不能连着两天工作或者健身，所以只需要考虑前一天休息或健身的情况
                    dp[PLAN.WORK.ordinal()][i] = Math.min(dp[PLAN.REST.ordinal()][i - 1], dp[PLAN.FITNESS.ordinal()][i - 1]);
                } else {
                    // 如果昨天不能去健身，那就只用考虑昨天休息的情况，由于今天在工作，所以今天的休息天数等于昨天休息的休息天数
                    dp[PLAN.WORK.ordinal()][i] = dp[PLAN.REST.ordinal()][i - 1];
                }
            } else {
                // 如果不能去工作，就给这一天的最少休息天数赋值为n，因为是求最少休息天数，肯定不会大于n,所以赋值为n不会影响。
                dp[PLAN.WORK.ordinal()][i] = total;
            }

            if (isWorking(gymDay[i])) { // 如果健身房开门，可以健身
                if (isWorking(companyDay[i - 1])) { // dp[PLAN.FITNESS.ordinal()][i] = min(前一天休息，前一天工作);
                    dp[PLAN.FITNESS.ordinal()][i] = Math.min(dp[PLAN.REST.ordinal()][i - 1], dp[PLAN.WORK.ordinal()][i - 1]);
                } else {
                    dp[PLAN.FITNESS.ordinal()][i] = dp[PLAN.REST.ordinal()][i - 1];
                }
            } else {
                dp[PLAN.FITNESS.ordinal()][i] = total;
            }

            // 今天休息的情况
            // dp[PLAN.REST.ordinal()][i] = min(前一天工作，前一天健身，前一天休息);
            int min_num = dp[PLAN.REST.ordinal()][i - 1]; // 先把如果昨天休息的最少休息天数记录下来
            // 因为今天是休息，昨天健身或者工作都是可以的
            if (isWorking(companyDay[i - 1])) { // 昨天工作
                min_num = Math.min(dp[PLAN.WORK.ordinal()][i - 1], min_num);
            }
            if (isWorking(gymDay[i - 1])) { // 昨天健身
                min_num = Math.min(dp[PLAN.FITNESS.ordinal()][i - 1], min_num);
            }
            // 如果昨天健身和工作都不可以，直接在昨天休息的休息天数上面加一
            dp[PLAN.REST.ordinal()][i] = min_num + 1;
        }
        return Math.min(Math.min(dp[PLAN.WORK.ordinal()][total - 1], dp[PLAN.FITNESS.ordinal()][total - 1]), dp[PLAN.REST.ordinal()][total - 1]);
    }
}
